package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.enums.ResourceStatusFlagEnum;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.check.CheckGroupDto;
import qc.module.ehs.entity.EhsCheckGroup;
import qc.module.ehs.entity.EhsCheckItem;
import qc.module.ehs.mapper.EhsCheckGroupMapper;
import qc.module.ehs.repository.EhsCheckGroupRepository;
import qc.module.ehs.repository.EhsCheckItemRepository;

import java.util.List;
import java.util.Objects;

/**
 * 检查项分组信息接口Service
 *
 * @author QuCheng Tech
 * @create 2024/10/23
 */
@Service
public class EhsCheckGroupService {
    
    @Autowired
    private EhsCheckGroupRepository repository;

    @Autowired
    private EhsCheckItemRepository checkItemRepository;

    @Autowired
    private EhsCheckTableService checkTableService;

    /**
     * 获取指定表的分组
     *
     * @param tableId 检查表ID
     * @return List<CheckGroupDto>
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public List<CheckGroupDto> getTableGroups(String tableId){

        LambdaQueryWrapper<EhsCheckGroup> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsCheckGroup::getTableid, tableId);
        //检查表分组排序
        wrapper.orderByAsc(EhsCheckGroup::getOdr).orderByAsc(EhsCheckGroup::getTableid);
        List<EhsCheckGroup> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsCheckGroupMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 获取指定检查表分组
     *
     * @param id 检查表分组ID
     * @return CheckGroupDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public CheckGroupDto get(String id){
        
        EhsCheckGroup en = repository.selectById(id);
        if (Objects.nonNull(en)){
            return EhsCheckGroupMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /**
     * 新增检查分组
     *
     * @param dto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public String add(CheckGroupDto dto){
        //1.DTO有效性验证
        if (StringUtils.isBlank(dto.getTableid())) return QCUnifyReturnValue.Warn("检查表ID不能为空");
        if (StringUtils.isBlank(dto.getTitle())) return QCUnifyReturnValue.Warn("标题不能为空");
        if (!checkTableService.isExist(dto.getTableid())) return QCUnifyReturnValue.Warn("指定检查表信息不存在");
        
        //2.dto -> entity
        EhsCheckGroup en = EhsCheckGroupMapper.MAPPER.dtoToEntity(dto);
        en.setGroupid(IdentifierUtil.randomUUID());
        
        //3.保存数据
        if (repository.insert(en) < 0x1){
            return QCUnifyReturnValue.Warn("保存失败");
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改检查分组
     *
     * @param dto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public String update(CheckGroupDto dto){
        //1.DTO有效性验证
        if (StringUtils.isBlank(dto.getGroupid())) return QCUnifyReturnValue.Warn("分组ID不能为空");
        if (StringUtils.isBlank(dto.getTableid())) return QCUnifyReturnValue.Warn("检查表ID不能为空");
        if (StringUtils.isBlank(dto.getTitle())) return QCUnifyReturnValue.Warn("标题不能为空");
        if (!isExist(dto.getGroupid())) return QCUnifyReturnValue.Warn("指定检查分组信息不存在");
        if (!checkTableService.isExist(dto.getTableid())) return QCUnifyReturnValue.Warn("指定检查表信息不存在");

        //2.dto -> entity
        EhsCheckGroup en = EhsCheckGroupMapper.MAPPER.dtoToEntity(dto);
        
        //3.更新数据
        repository.updateById(en);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除检查分组
     *
     * @param id 检查分组ID
     * @param isLogicDelete 是否为逻辑删除；为true表示逻辑删除--修改记录标记，为false表示物理删除--从数据库表中删除记录
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     * @description 同时删除检查项
     */
    public String delete(String id,boolean isLogicDelete){
        EhsCheckGroup group = repository.selectById(id);
        if (isLogicDelete){
            //逻辑删除：修改分组状态
            group.setStatus(ResourceStatusFlagEnum.DELETED);
            repository.updateById(group);
        }else {
            //物理删除：同时删除检查项
            //获取指定检查表、指定分组的检查项，删除检查项
            LambdaQueryWrapper<EhsCheckItem> itemWrapper = new LambdaQueryWrapper<>();
            itemWrapper.eq(EhsCheckItem::getTableid,group.getTableid())
                    .eq(EhsCheckItem::getGroupid,id);
            List<EhsCheckItem> checkItems = checkItemRepository.selectList(itemWrapper);
            if (CollectionUtils.isNotEmpty(checkItems)){
                for (EhsCheckItem item : checkItems){
                    checkItemRepository.deleteById(item);
                }
            }
            //删除分组
            repository.deleteById(id);
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 指定检查分组是否存在
     *
     * @param id 分组ID
     * @return true表示存在，false表示不存在
     */
    public boolean isExist(String id){
        EhsCheckGroup en = repository.selectById(id);

        if (Objects.nonNull(en)) return true;
        return false;
    }
}
